Grokking Database Fundamentals for Tech Interviews
Rate this course
Ask Author
Contribute
Back to course home

0% completed

Vote For New Content
Introduction to Database Systems
Course Overview
Overview of Databases
Core Components of Database
Database Architectures
Relational Vs. Non-relational Databases
Data Storage Fundamentals
File Organization in DBMS
Data Compression and Encoding
Quiz
Introduction to Database Indexes
Single Level Indexing
Tree-Based Indexing Techniques
Hash-Based Indexing
Bloom Filters
Quiz
Understanding the Transaction
Atomicity
Consistency
Isolation
Durability
Quiz
Understanding the Concurrency Control
Optimistic vs. Pessimistic Concurrency Control
Lock-Based Concurrency Control
Timestamp-Based Concurrency Control
Multiversion Concurrency Control (MVCC)
Quiz
Fundamentals of Distributed Databases
Partitioning in Databases
Partitioning Types
Sharding in Databases
Distributed Query Processing
Quiz
Replication in Databases
Replication Topologies
Understanding the Consistency Models in Databases
The CAP Theorem and Its Implications
Quiz
Understanding the Consensus
Consensus algorithms
Leader Election Strategies
Quiz
Understanding the Fault Tolerance
Logging Mechanisms in Databases
Checkpointing and Recovery Basics
Coordinated Recovery in Distributed Systems
High Availability Through Replication and Failover
Ensuring Data Resilience: Redundancy, Mirroring, and Recovery
Quiz
Introduction to NoSQL
Key-Value Stores
Document-Oriented Databases
Column-Family and Wide-Column Stores
Graph Databases
Quiz
Quora System Design & Database Design
TikTok System Design & Database Design
Airbnb System Design & Database Design
Snapchat System Design & Database Design
Relational Vs. Non-relational Databases

Understanding various database models is fundamental to designing efficient, scalable, and robust database systems. This lesson explores the differences between relational and non-relational models.

Image

Relational Models

Introduced by E.F. Codd in 1970, the relational model organizes data into tables (also known as relations) consisting of rows and columns.

  • Tables: Each table represents an entity, with rows representing individual records and columns representing attributes of the entity.
  • Keys: Primary keys uniquely identify each record, while foreign keys establish relationships between tables.

Characteristics

  • Structured Schema: Enforces a predefined schema, ensuring data consistency and integrity.
  • ACID Compliance: Guarantees Atomicity, Consistency, Isolation, and Durability for transactions.
  • SQL Support: Utilizes Structured Query Language (SQL) for data manipulation and querying.

Advantages

  • Data Integrity: Strong enforcement of data constraints ensures accuracy and reliability.
  • Flexibility in Querying: Powerful SQL capabilities allow complex queries and data manipulations.
  • Standardization: Widely adopted standards facilitate interoperability between different DBMSs.

Disadvantages

  • Scalability Limitations: Vertical scaling (enhancing a single server) can be costly and has physical limits.
  • Rigid Schema: Adapting to changing data requirements may require significant schema modifications.
  • Performance Overheads: Complex joins and transactions can lead to performance bottlenecks in large-scale applications.

Examples

  • Oracle Database
  • Microsoft SQL Server
  • MySQL
  • PostgreSQL

Non-Relational Models (NoSQL)

Non-relational databases, often referred to as NoSQL (Not Only SQL) databases, provide flexible data models designed to handle unstructured or semi-structured data, high scalability, and distributed data storage.

Types of NoSQL Databases

  1. Document Stores

    • Structure: Store data in documents, typically using JSON, BSON, or XML formats.
    • Flexibility: Schema-less design allows varying data structures within the same collection.
    • Use Cases: Content management systems, real-time analytics.
    • Examples: MongoDB, CouchDB
  2. Key-Value Stores

    • Structure: Store data as simple key-value pairs.
    • Simplicity: Highly efficient for read/write operations where the key is known.
    • Use Cases: Session management, caching, real-time data feeds.
    • Examples: Redis, Riak, Amazon DynamoDB
  3. Column-Family Stores

    • Structure: Organize data into columns grouped into families, allowing storage of large volumes of data.
    • Scalability: Designed for high write and read throughput across distributed systems.
    • Use Cases: Time-series data, big data applications.
    • Examples: Apache Cassandra, HBase
  4. Graph Databases

    • Structure: Use graph structures with nodes, edges, and properties to represent and store data.
    • Flexibility: Excellent for handling complex relationships and interconnected data.
    • Use Cases: Social networks, recommendation engines, fraud detection.
    • Examples: Neo4j, Amazon Neptune

Characteristics

  • Flexible Schema: Allows dynamic data models that can evolve with application requirements.
  • Horizontal Scalability: Easily scales out across multiple servers or clusters.
  • Eventual Consistency: Many NoSQL systems prioritize availability and partition tolerance, offering eventual consistency over strict ACID compliance.

Advantages

  • Scalability: Optimized for distributed environments, handling large-scale data efficiently.
  • Performance: Tailored for specific use cases, offering high performance for targeted operations.
  • Flexibility: Accommodates diverse and evolving data structures without significant schema changes.

Disadvantages

  • Limited Standardization: Lack of universal query languages can lead to complexity in querying and integration.
  • Eventual Consistency: May not be suitable for applications requiring immediate consistency.
  • Complexity in Transactions: Handling complex transactions and ensuring data integrity can be challenging.

Examples

  • MongoDB (Document Store)
  • Redis (Key-Value Store)
  • Cassandra (Column-Family Store)
  • Neo4j (Graph Database)

Comparison: Relational vs. Non-Relational Models

FeatureRelational DatabasesNon-Relational Databases (NoSQL)
SchemaFixed and predefinedFlexible and dynamic
ScalabilityVertical scalingHorizontal scaling
Data IntegrityStrong ACID complianceVaries; often eventual consistency
Query LanguageSQLVaries (e.g., MongoDB uses MongoQL)
Data RelationshipsComplex joins and relationshipsOptimized for specific relationship types
Use CasesTransactional systems, ERP, CRMBig data, real-time analytics, IoT
ExamplesMySQL, PostgreSQL, OracleMongoDB, Cassandra, Redis, Neo4j
Database Architectures
Data Storage Fundamentals
Mark as Completed

On this page

Relational Models

Characteristics

Advantages

Disadvantages

Examples

Non-Relational Models (NoSQL)

Types of NoSQL Databases

Characteristics

Advantages

Disadvantages

Examples

Comparison: Relational vs. Non-Relational Models